GermanWikipedia - /page/entry.mu

Micron Document

`:top

Ein `!Array`! ([], `F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f für Areal, Bereich, Anordnung, Aufstellung u. a.) ist in der `F33f`_`[Informatik`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Informatik]`_`f eine `F33f`_`[Datenstruktur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenstruktur]`_`f-Variante, mit deren Verwendung „viele gleichartig strukturierte Daten […] verarbeitet werden sollen“.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f] Der Zugriff auf bestimmte Inhalte des Arrays erfolgt mit Hilfe von `F33f`_`[Indizes`#indizes]`_`f.

>>Contents

• `F0af`_`[Begriffe`#begriffe]`_`f

• `F0af`_`[Synonyme Bezeichnung ‚Feld‘`#synonyme-bezeichnung-feld]`_`f

• `F0af`_`[Weitere Synonyme`#weitere-synonyme]`_`f

• `F0af`_`[Indizes`#indizes]`_`f

• `F0af`_`[Sprachspezifische Unterschiede`#sprachspezifische-unterschiede]`_`f

• `F0af`_`[Array-Varianten`#array-varianten]`_`f

• `F0af`_`[Standard-Array`#standard-array]`_`f

• `F0af`_`[Dynamisches Array`#dynamisches-array]`_`f

• `F0af`_`[Assoziatives Array / Zuordnungstabelle`#assoziatives-array-zuordnungstabelle]`_`f

• `F0af`_`[Element-Datentyp`#element-datentyp]`_`f

• `F0af`_`[Dimensionen`#dimensionen]`_`f

• `F0af`_`[Eindimensionale Arrays`#eindimensionale-arrays]`_`f

• `F0af`_`[Mehrdimensional / In-sich-mehrdimensional`#mehrdimensional-in-sich-mehrdimensional]`_`f

• `F0af`_`[Mehrdimensional / Array enthält weiteres Array`#mehrdimensional-array-enth-lt-weiteres-array]`_`f

• `F0af`_`[Adressierung eines Arrays`#adressierung-eines-arrays]`_`f

• `F0af`_`[Speicherabbildungsfunktion`#speicherabbildungsfunktion]`_`f

• `F0af`_`[Dope-Vektor`#dope-vektor]`_`f

• `F0af`_`[Programmeffizienz`#programmeffizienz]`_`f

• `F0af`_`[Siehe auch`#siehe-auch]`_`f

• `F0af`_`[Weblinks`#weblinks]`_`f

• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Begriffe

>>>Synonyme Bezeichnung ‚Feld‘

Zum Teil wird für Arrays auch der Ausdruck `!Feld`! (aus `F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f ‚field‘, eine weitere mögliche Bedeutung von ‚Array‘) verwendet.

Dieser Ausdruck (wie auch `!`F33f`_`[Datenfeld`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenfeld]`_`f`!) gilt jedoch `*im Allgemeinen`* als elementares, Daten beschreibendes Konstrukt; es wird im `F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f eines `F33f`_`[Computerprogramms`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f zur Definition von oder Bezugnahme auf benannten Speicherplatz verwendet. Ein Feld in diesem Sinn `*ist`* kein Datentyp, sondern es `*hat einen Datentyp`*, und es ist unerheblich, ob es Teil eines Arrays oder einer übergeordneten Datenstruktur, z. B. `F33f`_`[Verbund`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Verbund_(Datentyp)]`_`f oder Record ist oder ein singulär definierter Speicherbereich.

Diese beiden sich wesentlich unterscheidenden Bedeutungen von ‚Feld‘ sind und waren immer wieder Anlass zu zum Teil heftigen Diskussionen.`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f]

„Der englische und gängigere Begriff ist Array“.`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]

>>>Weitere Synonyme

Gleichbedeutende Synonyme für Array sind, im Wesentlichen geprägt aus dem Einsatz in verschiedenen `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f, deren Terminologie und Entstehungsgeschichte oder durch Übersetzung aus dem Englischen: `!Tabelle (Table), Vektor, Reihe, Reihung, Aufstellung, Bereich, Gate Array, Matrix`! u. a.

Auch die verschiedenen Elemente eines Arrays werden mit unterschiedlichen Ausdrücken bezeichnet: Element, Komponente, Unterfeld, Feldelement, indizierte Variable – und zum Teil ebenfalls Feld oder Datenfeld. Dabei können als Untermenge des Arrays entweder die über einen bestimmten `*Indexwert`* adressierten Daten verstanden werden (oft als ‚vertikale‘ Dimension des Arrays bezeichnet) oder innerhalb einer solchen `*Struktur`* definierte Datenfelder (‚horizontale‘ Sicht).

>>Indizes

Zur Adressierung der Inhalte eines Arrays wird ein ‚Index‘ verwendet.

Der Index wird bei ‚`F33f`_`[Standard-Arrays`#standard-array]`_`f‘ in `F33f`_`[höheren Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Höhere_Programmiersprache]`_`f als `F33f`_`[Ganzzahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ganze_Zahl]`_`f angegeben.

‚`F33f`_`[Assoziative Arrays`#assoziatives-array-zuordnungstabelle]`_`f‘ erlauben dagegen die Verwendung von beliebigen, nicht notwendigerweise numerischen, aber eindeutigen Schlüsselwerten als Indizes.

Bei `F33f`_`[mehrdimensionalen`#dimensionen]`_`f Arrays gibt es für jede Dimension einen unabhängigen Index und eine unabhängige Länge.

Bei streng strukturierten Programmiersprachen wird die Zulässigkeit eines Indexes zur Laufzeit geprüft, damit der Zugriff auf ungültige Speicherbereiche unterbunden wird.

>>Sprachspezifische Unterschiede

Grundsätzlich können Arrays in den meisten `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f angelegt und verarbeitet werden. Neben den unterschiedlichen Ausdrücken, die sich in einzelnen Sprachen entwickelt haben, werden Arrays von den `F33f`_`[Compilern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f der Programmiersprachen, zum Teil auch in verschiedenen Sprachversionen, unterschiedlich umgesetzt und unterstützt. Beispiele:

• Unterscheidung Standardarray / assoziatives Array / nur Listen durch den Compiler der Programmiersprache

• Anzahl der möglichen Dimensionen (in-sich mehrdimensionale Arrays, Array-in-Array)

• Maximale Array-Größe

• Adressierung der Elemente (ab 0, ab 1 oder ab einem beliebigen Index, gegebenenfalls auch beginnend mit einem negativen Index)

• Anzahl der Unterfelder: fix, dynamisch/variabel je Dimension

• Format und Länge der Elementarfelder: einheitlich im ganzen Array, einheitlich je Dimension/Variable, individuell

• Unterstützung für Operationen auf Datenmengen im Array: nur auf Elemente, beliebige Strukturen, ganze Dimension, ganzes Array

• Wertzuweisung für Array-Elemente: Per Deklaration, durch Zuweisungsbefehle

• Adressierungsverfahren:

• Der Index ist eine Ganzzahl-Variable (die konkrete Adresse im Array wird bei Bezugnahme berechnet)

• Der Index ist ein Direktwert (die Adresse im Array wird zur Compilezeit berechnet)

• Der Index enthält den relativen Abstand zum Array-Beginn

• Der Index ist ein Suchschlüssel

Zugehörige Berechnungen können manuell programmiert werden oder werden durch den `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f teilweise oder vollständig automatisch durchgeführt.

In den meisten `!`F33f`_`[Assemblersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Assemblersprache]`_`f`! ist die Verarbeitung von Arrays zwar möglich, sie wird aber `F33f`_`[syntaktisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Syntaktisch]`_`f meist nicht speziell unterstützt und muss vom Programmierer explizit „nachgebaut“ werden: Der `F33f`_`[Programmierer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierer]`_`f `F33f`_`[implementiert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Implementierung]`_`f Array-Elemente so wie auch andere Variablen, reserviert zusätzlich den `F33f`_`[Speicherplatz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicherplatz]`_`f für n weitere Ausprägungen. Zur Verarbeitung ermittelt er die Position relevanter Elemente mit geeigneten `F33f`_`[Algorithmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Algorithmus]`_`f, zum Beispiel in einem `F33f`_`[Indexregister`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Indexregister]`_`f, und `F33f`_`[adressiert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Adressierung_(Rechnerarchitektur)]`_`f sie mit aufgabenspezifischen – nicht speziell auf die Array-Verarbeitung ausgerichteten – Anweisungen.

Beim `!Deklarieren`! werden Arrays in einer sprachspezifischen `F33f`_`[Syntax`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Syntax]`_`f formuliert. Beispiele:

• `B100`F9d9NameX (100)`f`b (Datenname plus Anzahl der Array-Elemente in runder Klammer): `F33f`_`[PL/I`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PL/I]`_`f

• `B100`F9d9NameX [100,...]`f`b (Datenname plus je Dimension die Anzahl der Array-Elemente in einer eckigen Klammer): `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]

• `B100`F9d9NameX [100][][]`f`b (Datenname plus je Dimension in eckigen Klammern die Anzahl der Array-Elemente): `F33f`_`[C/C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f,`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]

• `B100`F9d9NameX array (100)`f`b (Schlüsselwort 'array' plus Anzahl der Elemente in runder Klammer): `F33f`_`[Modula-2`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Modula-2]`_`f

• `B100`F9d9NameX occurs 100.`f`b (Schlüsselwort 'OCCURS' plus Anzahl der Elemente plus ggf. Klausel ‚Indexed by‘): `F33f`_`[Cobol`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Cobol]`_`f

• `B100`F9d9Dim NameX (100,...)`f`b (Schlüsselwort 'Dim' plus Variablenname plus Anzahl Elemente je Dimension (in einer runden Klammer)): `F33f`_`[VBA`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Basic_for_Applications]`_`f, 'Dimension' bei `F33f`_`[Fortran90/95`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fortran]`_`f

>>Array-Varianten

>>>Standard-Array

Mit Hilfe eines Arrays können die Daten eines üblicherweise einheitlichen `F33f`_`[Datentyps`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f so im `F33f`_`[Speicher`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerspeicher]`_`f eines `F33f`_`[Computers`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computer]`_`f abgelegt werden, dass ein Zugriff auf die Daten über Indizes möglich wird. Das Standard-Array ist im Gegensatz zum assoziativen Array auf `F33f`_`[ganzzahlige`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ganze_Zahl]`_`f Indizes zur Adressierung festgelegt. Ein Index beginnt, bei einem (eindimensionalen) Array mit N Elementen, standardmäßig je nach `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f bei `*0`* (`F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f: 0,1,2,…,N-1) oder `*1`* (`F33f`_`[Fortran`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fortran]`_`f: 1,2,3,…,N), kann jedoch oftmals auch frei gewählt werden (42,43,44,…,N+41).

>>>Dynamisches Array

Ein dynamisches Array oder eine Array-Liste, eine `F33f`_`[Listendatenstruktur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Liste_(Datenstruktur)]`_`f mit variabler Größe und `F33f`_`[wahlfreiem Zugriff`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wahlfreier_Zugriff]`_`f, wo Elemente hinzugefügt oder entfernt werden können. Es wird von `F33f`_`[Standardbibliotheken`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Standardbibliothek]`_`f vieler moderner `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f zur Verfügung gestellt.

Ein dynamisches Array ist nicht dasselbe wie ein dynamisch zugewiesenes Array, bei dem es sich um ein Array handelt, dessen Größe bei der Zuweisung des Arrays festgelegt wird, obwohl ein dynamisches Array ein solches Array mit fester Größe möglicherweise als Back-End verwendet.

Ein einfaches dynamisches Array kann durch Zuweisen eines Arrays mit fester Größe erstellt werden, das normalerweise größer ist als die Anzahl der unmittelbar erforderlichen Elemente. Die Elemente des dynamischen Arrays werden am Anfang des zugrunde liegenden Arrays zusammenhängend gespeichert, und die verbleibenden Positionen gegen Ende des zugrunde liegenden Arrays werden reserviert oder nicht verwendet. Elemente können am Ende eines dynamischen Arrays in konstanter `F33f`_`[Laufzeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeit_(Informatik)]`_`f unter Verwendung des reservierten Speicherplatzes hinzugefügt werden, bis dieser `F33f`_`[Speicherplatz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicherplatz]`_`f vollständig belegt ist.

Wenn der gesamte `F33f`_`[Speicherplatz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicherplatz]`_`f belegt ist und ein zusätzliches Element hinzugefügt werden soll, muss das zugrunde liegende Array mit fester Größe vergrößert werden. Normalerweise ist die Größenänderung teuer, da ein neues zugrunde liegendes Array zugewiesen und jedes Element aus dem ursprünglichen Array kopiert werden muss. Elemente können in konstanter Zeit vom Ende eines dynamischen Arrays entfernt werden, da keine Größenänderung erforderlich ist. Die Anzahl der Elemente, die vom Inhalt des dynamischen Arrays verwendet werden, ist seine `*logische Größe`*, während die Größe des zugrunde liegenden Arrays als `*Kapazität`* oder `*physische Größe`* des dynamischen Arrays bezeichnet wird. Dies ist die maximale mögliche Größe, die verwendet werden kann, ohne Daten zu verschieben.

Ein dynamisches Array wird benötigt, wenn die maximale logische Größe nicht festgelegt ist oder nicht berechnet werden kann, bevor der Speicherplatz für das Array reserviert wird.

>>>Assoziatives Array / Zuordnungstabelle

→

Hauptartikel

Zuordnungstabelle

Eine Sonderform bildet das „assoziative Array“, auch „Zuordnungstabelle“ genannt. Es verwendet keine notwendigerweise `F33f`_`[ganzzahligen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ganze_Zahl]`_`f numerischen Indizes, sondern `F33f`_`[Schlüssel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Nummerung]`_`f zur Adressierung der Elemente. Diese Schlüssel können prinzipiell beliebigen Typs sein, zum Beispiel `F33f`_`[Zeichenketten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeichenkette]`_`f, müssen aber ein Element `F33f`_`[eindeutig`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eindeutigkeit]`_`f `F33f`_`[identifizieren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Identifikator]`_`f. Beispiel: Die Produktnummer ist der Index, mit dem Daten zu einem bestimmten Produkt in einer Produkttabelle indiziert werden, z. B.: `B100`F9d9Produkt = ProdBezeichn (ProdNr)`f`b.

„Assoziativ“ werden solche Arrays nur genannt, wenn der die tatsächliche Datenadresse berechnende `F33f`_`[Suchalgorithmus`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Suchalgorithmus]`_`f von der Programmiersprache automatisch generiert wird. Am häufigsten werden assoziative Felder als `F33f`_`[Hashtabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hashtabelle]`_`f umgesetzt.

>>Element-Datentyp

In `F33f`_`[statisch typisierenden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Statische_Typisierung]`_`f `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f sind Array-Inhalte teilweise auf Elemente eines einzelnen Datentyps eingeschränkt. Mitunter ist jedoch ein Spezialfall „weitgehend beliebiger Inhalt“ möglich, bei `F33f`_`[objektorientierten Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmiersprache]`_`f oft über `F33f`_`[Polymorphie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Polymorphie_(Programmierung)]`_`f der allgemeinen `F33f`_`[Basisklasse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Basisklasse]`_`f. In `F33f`_`[dynamisch typisierenden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamische_Typisierung]`_`f Programmiersprachen können meist `F33f`_`[Objekte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f oder allgemeine `F33f`_`[Datenstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenstruktur]`_`f in fast beliebiger Zusammensetzung und Reihenfolge gespeichert werden. In dynamisch typisierenden Programmiersprachen werden jedoch oft nur assoziative Arrays angeboten.

>>Dimensionen

In den meisten `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f kann ein Array – und damit die darin gespeicherten Daten – nicht nur ein-, sondern mehrdimensional sein. Bei mehrdimensionalen Feldern wird zur Adressierung ihrer Elemente für jede Dimension ein eigener Index verwendet. Zum Begriff der Dimension können die nachfolgenden Varianten unterschieden werden. In den Beispielen wird ein symbolischer Beispielcode verwendet, der Startindex sei 1.

>>>Eindimensionale Arrays

Die Feldelemente werden wie in einer `F33f`_`[Liste`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Liste_(Datenstruktur)]`_`f als elementares Datenfeld oder als `F33f`_`[Verbund`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Verbund_(Datentyp)]`_`f mit mehreren untergeordneten Elementarfeldern geführt. Der Zugriff auf die Informationen erfolgt über 'ArrayName (Index)'.

`!Beispiele`!

1. eindimensional (wie eine ‚Liste‘)

`B100`F9d9Vektor := array(3) of float // Deklaration einer 1-dimensionalen Liste namens „Vektor“ mit 3 ‚freien Plätzen‘`f`b

`B100`F9d9 Vektor := (0.5, 1.7, -0.2) // der Punkt (x=0.5 ; y=1.7 ; z=-0.2) im ℝ³`f`b

`B100`F9d9Vektor[2]`f`b liefert so die y-Komponente mit dem Wert `B100`F9d91.7`f`b.

2. eindimensional (mit Verbund-Datentyp):

`B100`F9d9Produkt := array(100) of structure{`f`b

`B100`F9d9 ProdNr := Text[6] // Text mit max. 6 Stellen`f`b

`B100`F9d9 Einkaufspreis := FixPunktZahl[4;2] // Kommazahl mit 4 Stellen vor, 2 Stellen nach dem Komma`f`b

`B100`F9d9 Verkaufspreis := FixPunktZahl[4;2] // dito`f`b

`B100`F9d9 Lagerbestand := Integer[6] // Ganzzahl mit 6 Stellen`f`b

`B100`F9d9 } // end structure`f`b

`B100`F9d9Produkt(Index).ProdNr, Produkt(Index).Einkaufspreis`f`b liefern die genannten Werte für das Produkt, auf das der Index zeigt.

>>>Mehrdimensional / In-sich-mehrdimensional

Mit dieser Variante lassen sich Informationen wie Elemente einer `F33f`_`[zweidimensionalen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zweidimensional]`_`f Fläche oder eines `F33f`_`[dreidimensionalen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dreidimensional]`_`f Würfels vorstellen. Dabei „beinhaltet nur die letzte Dimension die Elemente,“`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f] jede Einzelinformation ist somit `*allen Dimensionen`*, z. B. Breite, Höhe, Tiefe, gleichermaßen zuzurechnen. Der Zugriff erfolgt unter Angabe aller Indizes ('<AttrName>(i1,i2,...)'). ISO_IEC 11404 nennt diese Arrays unter den ‚General Purpose Datatypes‘ „inhärent mehrdimensional“. Diese mehrdimensionalen Arrays werden, vor allem im Bereich des `F33f`_`[Deep Learning`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deep_Learning]`_`f, nach ihrer mathematischen Entsprechung auch als `F33f`_`[Tensoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tensor]`_`f bezeichnet.`:cite-ref-whitepaper2015-8-0[`F5bf`_`[8`#cite-note-whitepaper2015-8]`_`f]

`!Beispiele`!

1. zweidimensional (wie eine Matrix oder eine Tabelle):

In einer Matrix werden die waagerechten Einträge (`*Felder`*, `*Zellen`*) als `*Zeilen`*, die Senkrechten als `*Spalten`* bezeichnet. Ein einzelnes Element ist also durch Nennung von Zeile und Spalte eindeutig bezeichnet (`*adressiert`*). Üblich ist die Adressierung über ein `F33f`_`[Tupel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tupel]`_`f (0,0) oder A1 für Spalte A, Zeile 1.

`B100`F9d9Schachbrett := array(8,8) of String`f`b

`B100`F9d9array`f`b deklariert `B100`F9d9Schachbrett`f`b als Array („Feld“) mit 8 mal 8 Einträgen, `B100`F9d9of`f`b deklariert den Typ des Eintrags, hier `B100`F9d9String`f`b.

`B100`F9d9 Schachbrett := ((„w_Turm“ ,"w_Springer","w_Läufer","w_König","w_Dame" ,"w_Läufer","w_Springer","w_Turm" ),`f`b

`B100`F9d9 („w_Bauer“,"w_Bauer" ,"w_Bauer" ,"w_Bauer","w_Bauer","w_Bauer" ,"w_Bauer" ,"w_Bauer"),`f`b

`B100`F9d9 ("" ,"" ,"" ,"" ,"" ,"" ,"" ,"" ),`f`b

`B100`F9d9 („s_Bauer“,"s_Bauer" ,"s_Bauer" ,"s_Bauer","s_Bauer","s_Bauer" ,"s_Bauer" ,"s_Bauer"),`f`b

`B100`F9d9 („s_Turm“ ,"s_Springer","s_Läufer","s_König","s_Dame" ,"s_Läufer","s_Springer","s_Turm" ))`f`b

Die vorstehende Zuweisung legt die Start-Anordnung der Figuren fest, `B100`F9d9w_`f`b=weiß, `B100`F9d9s_`f`b=schwarz. D. h. oben sitzt der Spieler der weißen Figuren und unten der der schwarzen.

Im Beispiel läuft der Spaltenindex von links nach rechts, der Zeilenindex von oben nach unten. Im Folgenden sei der Zeilenindex der erste und der Spaltenindex der zweite Index, die Indizierung also `B100`F9d9Schachbrett[Zeilenindex,Spaltenindex]`f`b. Der Spaltenindex „läuft schneller“.

Beim `F33f`_`[Schach`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachnotation]`_`f werden die Spalten als `*Linien`* bezeichnet und mit den Kleinbuchstaben „a“–„h“ adressiert, die Zeilen als `*Reihen`*, adressiert per „1“–„8“. Somit entspricht `B100`F9d9Schachbrett[z,s]`f`b dem Feld („a“–„h“)[9-`B100`F9d9s`f`b]`B100`F9d9z`f`b.

Die Beispielanweisungen `B100`F9d9Schachbrett[5,4]*1 := Schachbrett[5,2]*2`f`b und `B100`F9d9Schachbrett[5,2]*1 := ""`f`b liefern den Eröffnungszug „`B100`F9d9d2–d4`f`b“.

*1: oder [NachZeile,NachSpalte] *2: oder [VonZeile,VonSpalte]

2. mehrdimensional (hier mit 4 Dimensionen):

Für einen Brennraum (x;y;z) (z. B. eines Motors),

wobei x, y und z in Millimeter jeweils von 1 bis 50 angegeben seien,

sei an jeder Stelle, und über den Zeitraum einer Sekunde für jede Millisekunde, eine Temperaturangabe gespeichert:

`B100`F9d9 temperatur := array(50,50,50,1000) of float`f`b

→ 4-dimensionales Array (x,y,z,zeit)

Wie heiß war es an der Stelle (x=7;y=12;z=48) zum Zeitpunkt t=617 ms?

`B100`F9d9 = temperatur( 7 , 12 , 48 , 617 )`f`b

>>>Mehrdimensional / Array enthält weiteres Array

Hierbei enthält ein Array als Element – neben meist anderen Datenfeldern – wiederum ein Array usw. mit gegebenenfalls weiteren Stufen. Diese Variante wird auch `*verzweigtes Array`* genannt.`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f]`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f] Im Array gespeicherte Informationen gehören dabei jeweils zu `*genau einer Dimension,`* und zu genau einer ihrer Indexausprägungen. Die Anzahl der Dimensionen ergibt sich aus der „Schachtelungstiefe“ des innersten Arrays. ISO_IEC 11404 nennt diese Arrays „induziert mehrdimensional“. Zugriffe auf Informationen im äußeren Array erfolgen zum Beispiel mit '<Attr_in_Dim1>(i)', auf Informationen im inneren Array (z. B. bei dreidimensional) mit '<Attr_in_Dim3>(i1,i2,i3)'.

`!Beispiel ‚Daten für ein Lagerregal‘`!

`B100`F9d9 Regal: // umfasst das ganze Regal`f`b

`B100`F9d9 Regalboden := array(10) // Es gibt 10 Regalböden = Array der 1. Dimension`f`b

`B100`F9d9 RB_Bezei := Text(20) // wie der jeweilige Regalboden genannt/beschriftet wird`f`b

`B100`F9d9 … // ggf. weitere Daten je Regalboden, z. B. max. Gesamtgewicht`f`b

`B100`F9d9 WZ_Box := array(5) // Je Regalboden max. 5 Werkzeugboxen, 2. Dimension`f`b

`B100`F9d9 WZ_Bezei := Text(20) // Bezeichnung der Werkzeuge, die in der Box gelagert bzw. zu lagern sind`f`b

`B100`F9d9 WZ_Anz := numeric(4) // die Anzahl der darin gelagerten Werkzeuge`f`b

`B100`F9d9 … // ggf. weitere Daten je WZ-Box, u. U. weiteres Array 3. Dim.`f`b

`B100`F9d9'RB_Bezei (I1), "Box-Nr:" & I2, WZ_Bezei [I1,I2], WZ_Anz [I1,I2] ...'`f`b

`B100`F9d9 // liefert die Werkzeug-Bezeichnung und ihre Anzahl, die in einer bestimmten Box`f`b

`B100`F9d9 // (Regalboden und Box-Nr) gelagert sind.`f`b

`B100`F9d9'RB_Bezei (I1)'`f`b // liefert die Bezeichnung des Regalbodens.

`B100`F9d9'WZ_Bezei (I1,I2) = "Rohrzangen", WZ_Anz (I1, I2) = 10' `f`b legt eine neue WZ-Box mit 10 Rohrzangen an.

`B100`F9d9'WZ_Anz (I1,I2) -1`f`b aktualisiert die Anzahl bei Entnahme eines Werkzeugs aus der Box.

In den Anweisungen sind Indizes für die inneren Dimension(en) (> 1) nur anzugeben, wenn aus ihnen Informationen angesprochen/abgerufen werden, z. B. RB_Bezei(x) oder WZ_Bezei(x,y).

Sollte das Lager aus mehreren (z. B. 4) Regalen bestehen, müsste vor 'Regalboden' eine weitere Dimension 'Regal := array (4)' – optional mit ‚eigenen‘ Info-Elementen (wie etwa Breite) – definiert und bei Zugriffen der Index für diese neue Dimension 1 zusätzlich spezifiziert werden.

>>Adressierung eines Arrays

Die Speicheradresse eines durch einen Index bezeichneten Inhalts wird, ausgehend von der für das erste Element festgelegten Speicheradresse plus indexabhängige Distanz (berechnet über den aktuellen Index-Inhalt minus Index-Erstwert, multipliziert mit der Länge des Inhalts der Array-Datengruppe) gebildet.

Trotz der meist räumlich dargestellten Inhalte von Arrays, besonders bei mehrdimensionalen, werden auch die in einem Array gespeicherten Elemente in einem `*linearen`* Speicher abgelegt. Die Elemente eines eindimensionalen Vektors werden hintereinander im Speicher abgelegt, bei einer zweidimensionalen Matrix werden die Elemente entweder als Zeilen- oder als Spaltenvektoren hintereinander abgelegt, bei einem dreidimensionalen Array werden entsprechend viele Matrizen hintereinander abgelegt usw.

Bei den meisten `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f wird das Adressieren von Arrays vollständig vom `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f behandelt. In `F33f`_`[Assembler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Assemblersprache]`_`f muss es im `F33f`_`[Quellcode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quellcode]`_`f explizit programmiert werden.

>>>Speicherabbildungsfunktion

Ein `F33f`_`[Programm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f, das auf Elemente eines Arrays zugreifen will, muss deren `F33f`_`[Speicheradresse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicheradresse]`_`f errechnen.

`!Beispiel`!

Gegeben: Ein 2-dimensionales Array mit 4 Zeilen (1..4) und 7 Spalten (1..7). Jedes Element sei 4 Byte groß. Es soll zugegriffen werden auf das Element an (Zeile = 3, Spalte = 6). Das Array beginne bei Speicheradresse `*base`*.

Da auf ein Element der Zeile 3 zugegriffen wird, müssen 2 Zeilen „übersprungen“ werden:

2 (Zeilen überspringen) * 7 (Elemente pro Zeile) * 4 (Byte pro Element) = 56 (= Beginn der 3. Zeile im Array)

In der Zeile 3 soll auf Spalte 6 zugegriffen werden, also sind zusätzlich 5 Elemente zu „überspringen“:

5 (Spalten überspringen) * 4 (Byte pro Element) = 20 (= Beginn der 6. Spalte in Zeile 3)

Das gewünschte Element beginnt also an Adresse (`*base`* + 56 + 20) = (`*base`* + 76) und ist 4 Byte lang.

`!Allgemein`!

In einem n {\\displaystyle n} -dimensionalen Array A [ i 1 : k 1 , i 2 : k 2 , … … , i n : k n ] {\\displaystyle A[i_{1}:k_{1},i_{2}:k_{2},\\ldots ,i_{n}:k_{n}]} wird die Adresse eines Elements a [ j 1 , j 2 , . . , j n ] {\\displaystyle a[j_{1},j_{2},..,j_{n}]} beispielsweise mit Hilfe der Formel ( j n − − i n ) + ∑ ∑ s = 1 n − − 1 ( ( j s − − i s ) ⋅ ⋅ ∏ ∏ t = s + 1 n ( k t − − i t + 1 ) ) {\\displaystyle (j_{n}-i_{n})+\\sum _{s=1}^{n-1}((j_{s}-i_{s})\\cdot \\prod _{t=s+1}^{n}(k_{t}-i_{t}+1))} berechnet. Man nennt diese Formel auch `!Speicherabbildungsfunktion`!.

Die dargestellte Formel ist nur eine von mindestens zwei Alternativen, je nachdem, in welcher Reihenfolge die Indizes zu Speicherblöcken zusammengefasst werden, vom Ersten hin zum Letzten oder gerade umgekehrt. Im Englischen unterscheidet man hier `*Row-major order`* (zeilenweise Anordnung) und `*Column-major order`* (spaltenweise Anordnung).

Es ist normalerweise Sache der `F33f`_`[Laufzeitumgebung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeitumgebung]`_`f des jeweiligen `F33f`_`[Compilers`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f, diese Berechnungen vorzunehmen und im jeweiligen Befehl zu verwenden, egal nach welcher Variante.

>>>Dope-Vektor

Da die Produkte ∏ ∏ t = s + 1 n ( … … ) {\\displaystyle \\prod _{t=s+1}^{n}(\\ldots )} in obiger Formel konstant sind, können sie einmalig berechnet werden. Der daraus resultierende `*Dope-Vektor`* `!d`! ermöglicht anschließend über die Formel deg t = 1 n ⁡ ⁡ ( j t − − i t ) ⋅ ⋅ d t {\\displaystyle \\deg _{t=1}^{n}(j_{t}-i_{t})\\cdot d_{t}} eine sehr schnelle Berechnung der Adresse eines jeden gespeicherten Elements.

>>>Programmeffizienz

Die Verarbeitung von Daten innerhalb eines Arrays erfordert – im Gegensatz zu ohne Index adressierbaren Datenfeldern – zusätzlichen Aufwand zur Berechnung der tatsächlichen `F33f`_`[Speicheradresse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicheradresse]`_`f verwendeter Datenfelder. Die dazu nötigen, meist von einem `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f erzeugten Berechnungsbefehle kann der Programmierer zum Teil beeinflussen und optimieren – sofern dies nicht bereits durch den Compiler geschieht. Die folgenden Beispiele nennen Details, deren Anwendung zu effizienterem `F33f`_`[Code`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Code]`_`f führen kann, Details und weitere Beispiele siehe.`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f]

• Bei `*Literalen als Index`* berechnet der `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f die `F33f`_`[Speicheradresse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speicheradresse]`_`f meist zur `F33f`_`[Compilezeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compilezeit]`_`f. Manche Compiler stellen fest, ob der Index von Variablen abhängt, deren Stand zur Compilezeit bereits bestimmt werden kann.

• Verwenden von `*internen Datenformaten`* für die Indexvariable, damit im Rahmen der Adressierungsberechnung nicht auch noch eine Formatkonvertierung erforderlich ist.

• `*Wiederverwenden`* bereits berechneter Zugriffsadressen, anstatt sie für jeden Befehl erneut zu berechnen. Je nach Compiler können dazu geeignete Adressierungsmethoden gewählt werden, zum Teil stellen Compiler diese Wiederverwendung fest und erzeugen automatisch optimierten Code.

• Eine geeignete Wahl der `*Reihenfolge der Dimensionen:`* Wenn in einem Computer ein Array im `F33f`_`[RAM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Random-Access_Memory]`_`f gehalten wird, erfolgen Zugriffe auf Arrayelemente in der Regel am schnellsten, wenn direkt aufeinander folgende Adressen abgerufen werden (`F33f`_`[Lokalität`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lokalitätseigenschaft]`_`f ermöglicht `F33f`_`[Caching`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Cache]`_`f). Der Programmierer ist also gehalten, die Reihenfolge der Indizes im Array so festzulegen, dass dies in der innersten Schleife ebenso erfolgt. Da die Speicherabbildungsfunktion vom Compiler abhängt, sollte sich der Programmierer über diese Details informieren und dann im Programm den in der innersten Schleife durchlaufenen Index so definieren, dass er im RAM aufeinanderfolgenden Elementen entspricht.

• Übergeordnete `F33f`_`[Verbundstruktur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Verbund_(Datentyp)]`_`f ansprechen anstatt vieler elementarer Datenfelder, zum Beispiel beim Verschieben oder Sortieren von Array-Einträgen; die Adressberechnung findet dabei nur einmal je Verbund statt – dagegen bei Bezug auf einzelne Elemente des Verbunds je Verbund-Element.

• `*Auslagern`* von Array-Inhalten bei (ort-/zeitlokal) mehreren/vielen Zugriffen mit gleichem Index in einen eigenen, direkt adressierbaren Speicherbereich. Beispiel: Ein 100er Array mit `B100`F9d9Dim(101)`f`b definieren, Vor der Verarbeitung Inhalt(index) dorthin übertragen und in Einzelbefehlen Elemente mit Index-Direktwert `B100`F9d9‚101‘`f`b adressieren: Dabei ist die Adressberechnung nur einmal erforderlich.

Die Zweckmäßigkeit oder Notwendigkeit derartiger Effizienzmaßnahmen, die aus Gründen der Lesbarkeit eines Programms stets gut dokumentiert sein sollten, hängt von verschiedenen Faktoren ab: Nicht relevant sind sie, wenn der verwendete `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f entsprechende Optimierungen automatisch vornimmt, weniger relevant zum Beispiel, wenn das `F33f`_`[Programm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f nur selten ausgeführt wird, wenn es jeweils nur eine kurze `F33f`_`[Laufzeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeit_(Informatik)]`_`f hat, wenn die Array-bezogenen Befehle nur einen geringen Teil der Gesamtverarbeitung ausmachen.

>>Siehe auch

• `F33f`_`[Liste (Datenstruktur)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Liste_(Datenstruktur)]`_`f

• `F33f`_`[Stapelspeicher`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f

• `F33f`_`[Warteschlange (Datenstruktur)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Warteschlange_(Datenstruktur)]`_`f

• `F33f`_`[Baum (Graphentheorie)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Baum_(Graphentheorie)]`_`f

• `F33f`_`[Range Minimum Query`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Range_Minimum_Query]`_`f

• `F33f`_`[Vektorprozessor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Vektorprozessor]`_`f

• `F33f`_`[Zuweisungskompatibilität`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zuweisungskompatibilität]`_`f

• `F33f`_`[Tabellenkalkulation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tabellenkalkulation]`_`f

>>Weblinks

Wiktionary: Array

– Bedeutungserklärungen, Wortherkunft, Synonyme, Übersetzungen

Commons

: Array-Datenstruktur

– Sammlung von Bildern, Videos und Audiodateien

Wikibooks: Algorithmen und Datenstrukturen in C/ Felder

– Lern- und Lehrmaterialien

• Das Array, unendliche Weiten? – Dimensionen von Arrays; auf aspheute.com

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f `*Programmieren in Fortran`* (archiviert), Uni Bayreuth

`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f Beispiel für „heftige Diskussion“ auf leo.org

`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f Ein C-Tutorial. C-how-to

`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f msdn.microsoft.com Microsoft

`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f `F33f`_`[Martin-Luther-Universität Halle-Wittenberg`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Martin-Luther-Universität_Halle-Wittenberg]`_`f: `*C/C++ – Arrays`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 29. April 2015 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*)

`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f homeandlearn.co.uk Java

`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f Programmersbase Tutorial / Java Grundlagen / Arrays (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 23. Februar 2015 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*)

`:cite-note-whitepaper2015-8`!8.`! `F0af`_`[↑`#cite-ref-whitepaper2015-8-0]`_`f `F33f`_`[Jeff Dean`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Jeff_Dean_(Informatiker)]`_`f, Rajat Monga, Sanjay Ghemawat: `*TensorFlow: Large-scale machine learning on heterogeneous systems.`* (PDF) In: `*TensorFlow.org.`* Google Research, 11. September 2015, abgerufen am 10. November 2015 (englisch).

`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f rheinwerk-verlag.de: `*Visual C# 2008 – 2.5 Datenfelder (Arrays)`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 20. Juni 2015 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*)

`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f MSDN msdn.microsoft.com

`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f `*Maximierung der Codeperformance …`* MathWorks, `*Technical Articles and Newsletters`*

`c`F0af`_`[↑ Back to top`#top]`_`f`a